---
title: "01-Java 平台概述"
aliases:
- "Java 平台概述"
created: 2025-12-23
---
# Java 平台概述
## **一、Java 发展简史**
```drawio
```
> 💡 ***LTS (Long-Term Support)**：长期支持版本，Oracle 提供至少 8 年的更新支持。目前的 LTS 版本1有：Java 8、11、17、21*
## **二、Java 的核心特性**
### **2.1 整体特性图**
```drawio
```
### **2.2 面向对象（OOP）**
Java 是**纯面向对象**语言，支持三大核心特性：
```java
// ======================== 封装 ========================
// 将数据和行为包装在一起，隐藏内部实现细节
public class BankAccount {
private double balance; // 私有属性，外部无法直接访问
public void deposit(double amount) { // 公开方法作为访问入口
if (amount > 0) {
this.balance += amount;
}
}
public double getBalance() { // 只读访问
return this.balance;
}
}
// ======================== 继承 ========================
// 子类复用父类的属性和方法，实现代码重用
public class Animal {
protected String name;
public void eat() {
System.out.println(name + " is eating");
}
}
public class Dog extends Animal { // Dog 继承 Animal
public void bark() {
System.out.println(name + " is barking");
}
}
// ======================== 多态 ========================
// 同一接口，不同实现；父类引用指向子类对象
public class Cat extends Animal {
@Override
public void eat() {
System.out.println(name + " eats fish"); // 重写父类方法
}
}
// 多态的体现
Animal animal1 = new Dog(); // 父类引用 → 子类对象
Animal animal2 = new Cat();
animal1.eat(); // 调用 Dog 的 eat（如果重写了）
animal2.eat(); // 调用 Cat 的 eat
```
多态的底层机制：
```drawio
```
### **2.3 跨平台性（Write Once, Run Anywhere）**
#### **原理图解**
```drawio
```
#### **跨平台的本质**
```java
// 同一份代码
public class CrossPlatformDemo {
public static void main(String[] args) {
System.out.println("当前操作系统: " + System.getProperty("os.name"));
System.out.println("Java 版本: " + System.getProperty("java.version"));
System.out.println("文件分隔符: " + java.io.File.separator);
}
}
```
```yaml
运行结果（不同平台）:
Windows: Linux: macOS:
当前操作系统: Windows 10 当前操作系统: Linux 当前操作系统: Mac OS X
Java 版本: 17.0.2 Java 版本: 17.0.2 Java 版本: 17.0.2
文件分隔符: \ 文件分隔符: / 文件分隔符: /
```
> *⚠️ **现代视角**：容器技术（Docker/K8s）成熟后，跨平台已不再是 Java 独有优势。Java 真正的核心竞争力是其**庞大成熟的生态系统**。*
### **2.4 内置多线程支持**
#### **Java vs C++ 多线程对比**
```java
// ==================== Java 多线程（语言原生支持）====================
public class JavaThread extends Thread {
@Override
public void run() {
System.out.println("Java 线程运行中: " + Thread.currentThread().getName());
}
public static void main(String[] args) {
new JavaThread().start();
// 或使用 Lambda（Java 8+）
new Thread(() -> System.out.println("Lambda 线程")).start();
// 或使用线程池
ExecutorService executor = Executors.newFixedThreadPool(4);
executor.submit(() -> System.out.println("线程池任务"));
}
}
```
```
// ==================== C++ 多线程（C++11 前需要依赖系统 API）====================
// C++11 之前 - Windows 平台
#include
DWORD WINAPI ThreadFunc(LPVOID lpParam) {
printf("Windows 线程\n");
return 0;
}
int main() {
CreateThread(NULL, 0, ThreadFunc, NULL, 0, NULL);
}
// C++11 之后 - 标准库支持
#include
int main() {
std::thread t([]() {
std::cout << "C++11 标准线程" << std::endl;
});
t.join();
}
```
#### **Java 并发包体系**
```drawio
```
### **2.5 自动内存管理（GC）**
#### **手动 vs 自动内存管理**
```
// ==================== C++ 手动内存管理 ====================
int main() {
int* arr = new int[100]; // 申请内存
// 使用内存...
delete[] arr; // 必须手动释放！
arr = nullptr; // 避免悬空指针
// 忘记 delete → 内存泄漏
// 重复 delete → 程序崩溃
// 使用已释放内存 → 未定义行为
}
```
```java
// ==================== Java 自动内存管理 ====================
public class MemoryDemo {
public static void main(String[] args) {
int[] arr = new int[100]; // 在堆上分配
// 使用内存...
arr = null; // 解除引用（可选）
// JVM 的 GC 会自动回收不再使用的对象
// 程序员无需关心何时释放
}
}
```
#### **GC 工作原理简图**
```drawio
```
### **2.6 安全机制**
```drawio
```
```java
// 类型安全示例
public class TypeSafetyDemo {
public static void main(String[] args) {
Object obj = "Hello";
// 编译期检查：必须显式转型
// int num = obj; // 编译错误！
// 运行时检查：类型转换安全
if (obj instanceof String str) { // Java 16+ 模式匹配
System.out.println(str.length());
}
// 数组边界检查
int[] arr = {1, 2, 3};
// arr[10] = 5; // 运行时抛出 ArrayIndexOutOfBoundsException
}
}
```
### **2.7 高性能优化（JIT 编译器）**
```drawio
```
#### **JIT 优化技术示例**
```java
public class JITOptimizationDemo {
// 1. 方法内联（Inlining）
// JIT 会将短小方法直接嵌入调用处，减少方法调用开销
public int add(int a, int b) {
return a + b;
}
public int calculate() {
// JIT 优化后，add 方法会被内联
// return add(1, 2); → return 1 + 2; → return 3;
return add(1, 2);
}
// 2. 逃逸分析（Escape Analysis）
public void process() {
// point 对象未逃逸出方法，JIT 可能在栈上分配（标量替换）
Point point = new Point(1, 2);
int sum = point.x + point.y;
System.out.println(sum);
}
// 3. 循环优化
public int loopSum() {
int sum = 0;
for (int i = 0; i < 1000; i++) {
sum += i;
}
// JIT 可能进行循环展开、消除边界检查等优化
return sum;
}
}
```
### **2.8 特性总结表**
| **特性** | **描述** | **核心优势** |
| --- | --- | --- |
| **面向对象** | 封装、继承、多态 | 代码复用、结构清晰 |
| **跨平台** | JVM 屏蔽底层差异 | 一次编写,到处运行 |
| **多线程** | 语言原生支持 + 并发包 | 高效并发编程 |
| **自动 GC** | 垃圾自动回收 | 降低内存泄漏风险 |
| **安全性** | 多层安全检查 | 类型安全、访问控制 |
| **高性能** | JIT 即时编译 | 接近原生代码性能 |
| **丰富类库** | 标准库 + 第三方生态 | 开发效率高 |
## **三、Java 平台版本体系**
### **3.1 三大版本对比**
```drawio
```
### **3.2 详细对比**
| **版本** | **全称** | **定位** | **包含内容** | **应用场景** |
| --- | --- | --- | --- | --- |
| **Java SE** | Standard Edition | 标准版 | JVM + 核心类库 + 开发工具 | 桌面应用、简单服务端 |
| **Java EE** | Enterprise Edition | 企业版 | SE + 企业级规范(Servlet/JPA/EJB...) | 大型分布式系统 |
| **Java ME** | Micro Edition | 微型版 | 精简版 SE | 嵌入式设备（已淘汰） |
### **3.3 Java SE 核心组成**
```
// Java SE 提供的核心 API 示例
// 1. 集合框架 (java.util)
import java.util.ArrayList;
import java.util.HashMap;
// 2. IO/NIO (java.io, java.nio)
import java.io.FileInputStream;
import java.nio.file.Files;
// 3. 网络编程 (java.net)
import java.net.Socket;
import java.net.HttpURLConnection;
// 4. 并发编程 (java.util.concurrent)
import java.util.concurrent.ExecutorService;
import java.util.concurrent.CompletableFuture;
// 5. 时间日期 (java.time) - Java 8+
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
// 6. 反射 (java.lang.reflect)
import java.lang.reflect.Method;
import java.lang.reflect.Field;
```
### **3.4 Java EE 核心规范**
```drawio
```
```java
// Java EE 应用示例 - Servlet
// Java EE (javax)
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// Jakarta EE (jakarta) - 新版
import jakarta.servlet.http.HttpServlet;
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
resp.setContentType("text/html;charset=UTF-8");
resp.getWriter().write("Hello, Java EE!
");
}
}
```
### **3.5 版本选择指南**
```drawio
```
## **四、Java 与 C++ 深度对比**
### **4.1 总体对比表**
| **对比维度** | **Java** | **C++** |
| --- | --- | --- |
| **设计理念** | 简单、安全、跨平台 | 高效、灵活、接近底层 |
| **编译执行** | 编译成字节码，JVM 解释/JIT执行 | 直接编译成机器码 |
| **内存管理** | 自动 GC，无需手动释放 | 手动 new/delete，或智能指针 |
| **指针操作** | 不支持指针，只有引用 | 完全支持指针运算 |
| **多重继承** | 单继承 + 多接口实现 | 支持多重继承 |
| **运算符重载** | 不支持 | 支持 |
| **泛型实现** | 类型擦除（编译期） | 模板（编译期代码膨胀） |
| **预处理器** | 无 | 有（#define, #include） |
| **跨平台** | JVM 保证 | 需重新编译 |
| **性能** | 略低于 C++（JIT 优化后接近） | 最高（直接机器码） |
### **4.2 代码对比示例**
#### **内存管理**
```java
// ==================== C++ ====================
#include
#include
class Person {
public:
std::string name;
Person(std::string n) : name(n) {
std::cout << "Person created: " << name << std::endl;
}
~Person() { // 析构函数
std::cout << "Person destroyed: " << name << std::endl;
}
};
int main() {
// 方式1: 手动管理（容易出错）
Person* p1 = new Person("Alice");
delete p1; // 必须手动释放！
// 方式2: 智能指针（推荐）
std::unique_ptr p2 = std::make_unique("Bob");
// 作用域结束自动释放
return 0;
}
```
```java
// ==================== Java ====================
public class Person {
private String name;
public Person(String name) {
this.name = name;
System.out.println("Person created: " + name);
}
// finalize 已被弃用，不推荐使用
// Java 9+ 推荐使用 Cleaner
public static void main(String[] args) {
Person p1 = new Person("Alice");
Person p2 = new Person("Bob");
p1 = null; // 解除引用
// GC 会在适当时机自动回收
System.gc(); // 建议 GC 运行（不保证立即执行）
}
}
```
#### **继承机制**
```java
// ==================== C++ 多重继承 ====================
class Flyable {
public:
virtual void fly() { std::cout << "Flying" << std::endl; }
};
class Swimmable {
public:
virtual void swim() { std::cout << "Swimming" << std::endl; }
};
// C++ 支持多重继承
class Duck : public Flyable, public Swimmable {
public:
void fly() override { std::cout << "Duck flying" << std::endl; }
void swim() override { std::cout << "Duck swimming" << std::endl; }
};
```
```java
// ==================== Java 单继承 + 多接口 ====================
interface Flyable {
default void fly() { // Java 8+ 接口默认方法
System.out.println("Flying");
}
}
interface Swimmable {
default void swim() {
System.out.println("Swimming");
}
}
// Java 单继承，但可实现多个接口
class Duck extends Animal implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("Duck flying");
}
@Override
public void swim() {
System.out.println("Duck swimming");
}
}
```
#### **泛型实现差异**
```java
// ==================== C++ 模板 ====================
template
class Box {
private:
T value;
public:
void set(T v) { value = v; }
T get() { return value; }
};
int main() {
Box intBox; // 编译时生成 Box 的代码
Box doubleBox; // 编译时生成 Box 的代码
// 代码膨胀：每种类型生成独立的代码
}
```
```java
// ==================== Java 泛型（类型擦除）====================
public class Box {
private T value;
public void set(T v) { value = v; }
public T get() { return value; }
}
public class Main {
public static void main(String[] args) {
Box intBox = new Box<>();
Box doubleBox = new Box<>();
// 运行时类型信息被擦除
System.out.println(intBox.getClass() == doubleBox.getClass()); // true
// 编译后实际是:
// class Box { Object value; ... }
}
}
```
### **4.3 应用场景对比**
```drawio
```
## **五、总结**
```drawio
```